﻿using System;
using System.Collections.Generic;
using System.Configuration;
using System.Data;
using System.Data.SqlClient;
using System.Linq;
using System.Web;

namespace FL.Web.BackEnd.Helper
{
    public class MssqlReportData
    {


        //★特别提示★：
        //连接SQL Server数据库的连接串，应该修改为与实际一致。如果是运行Grid++Report本身的例子，应该首先附加例子数据库到
        //SQL Server2000/2005数据库上。
        static public string SqlConnStr = ConfigurationManager.AppSettings["defualtConnString"];

        //定义在SQL中表示日期值的包围符号，Access用“#”, 而MS SQl Server用“'”，为了生成两者都可用的查询SQL语句，将其参数化定义出来。这样处理只是为了演示例子方便
        public const char DateSqlBracketChar = '\'';

        //<<根据SQL产生报表需要的 XML 数据
        //根据查询SQL,产生提供给报表生成需要的 XML 数据，采用 Sql 数据引擎
        public static void GenNodeXmlData(System.Web.UI.Page dataPage, string querySql, bool toCompress)
        {
            DoGenDetailData(dataPage, querySql, toCompress, false);
        }

        public static void GenNodeXmlData(HttpResponse response, string querySql, bool toCompress)
        {
            DoGenDetailData(response, querySql, toCompress, false);
        }
        public static void GenNodeXmlData(string querySql)
        {
            DoGenDetailData(querySql);
        }

        //根据查询SQL,产生提供给报表生成需要的 XML 数据，采用 Sql 数据引擎, 这里只产生报表参数数据
        //当报表没有明细时，调用本方法生成数据，查询SQL应该只能查询出一条记录
        public static void GenParameterReportData(System.Web.UI.Page dataPage, string parameterQuerySql)
        {
            DoGenParameterData(dataPage, parameterQuerySql, false);
        }

        public static void GenParameterReportData(HttpResponse response, string parameterQuerySql)
        {
            DoGenParameterData(response, parameterQuerySql, false);
        }

        //根据查询SQL,产生提供给报表生成需要的 XML 数据，采用 Sql 数据引擎, 根据RecordsetQuerySQL获取报表明细数据，根据ParameterQuerySQL获取报表参数数据
        public static void GenEntireReportData(System.Web.UI.Page dataPage, string recordsetQuerySql, string parameterQuerySql, bool toCompress)
        {
            DoGenEntireData(dataPage, recordsetQuerySql, parameterQuerySql, toCompress, false);
        }

        public static void GenEntireReportData(HttpResponse response, string recordsetQuerySql, string parameterQuerySql, bool toCompress)
        {
            DoGenEntireData(response, recordsetQuerySql, parameterQuerySql, toCompress, false);
        }

        //根据查询SQL,产生提供给报表生成需要的 XML 数据，采用 Sql 数据引擎，字段值为空也产生数据
        public static void FullGenNodeXmlData(System.Web.UI.Page dataPage, string querySql, bool toCompress)
        {

            using (var myConn = new SqlConnection(SqlConnStr))
            {
                using (var myCommand = new SqlCommand(querySql, myConn))
                {
                    using (var myReader = myCommand.ExecuteReader())
                    {
                        myConn.Open();
                        XmlReportData.GenNodeXmlDataFromReader(dataPage, myReader, toCompress);
                        myReader.Close();
                        myConn.Close();
                    }
                }
            }
        }
        //>>根据SQL产生报表需要的 XML 数据


        //<<根据SQL产生报表需要的 JSON 数据
        //根据查询SQL,产生提供给报表生成需要的 JSON 数据，采用 Sql 数据引擎
        public static void JSON_GenDetailData(System.Web.UI.Page dataPage, string querySql, bool toCompress)
        {
            DoGenDetailData(dataPage, querySql, toCompress, true);
        }

        //根据查询SQL,产生提供给报表生成需要的 JSON 数据，采用 Sql 数据引擎, 这里只产生报表参数数据
        //当报表没有明细时，调用本方法生成数据，查询SQL应该只能查询出一条记录
        public static void JSON_GenParameterData(System.Web.UI.Page dataPage, string parameterQuerySql)
        {
            DoGenParameterData(dataPage, parameterQuerySql, true);
        }

        //根据查询SQL,产生提供给报表生成需要的 JSON 数据，采用 Sql 数据引擎, 根据RecordsetQuerySQL获取报表明细数据，根据ParameterQuerySQL获取报表参数数据
        public static void JSON_GenEntireData(System.Web.UI.Page dataPage, string recordsetQuerySql, string parameterQuerySql, bool toCompress)
        {
            DoGenEntireData(dataPage, recordsetQuerySql, parameterQuerySql, toCompress, true);
        }
        //>>根据SQL产生报表需要的 JSON 数据


        //获取 Count(*) SQL 查询到的数据行数
        //参数 QuerySQL 指定获取报表数据的查询SQL
        public static int BatchGetDataCount(string querySql)
        {
            int total = 0;

            using (var myConn = new SqlConnection(SqlConnStr))
            {
                using (var myCommand = new SqlCommand(querySql, myConn))
                {
                    using (var myReader = myCommand.ExecuteReader())
                    {
                        myConn.Open();
                        if (myReader.Read())
                            total = myReader.GetInt32(0);
                        myReader.Close();
                        myConn.Close();
                    }
                }
            }
            return total;
        }


        //<<private function
        //根据查询SQL,产生提供给报表生成需要的 XML 或 JSON 数据，采用 Sql 数据引擎
        private static void DoGenDetailData(System.Web.UI.Page dataPage, string querySql, bool toCompress, bool isJson)
        {
            DoGenDetailData(dataPage.Response, querySql, toCompress, isJson);
        }

        private static void DoGenDetailData(HttpResponse response, string querySql, bool toCompress, bool isJson)
        {
            var myds = new DataSet();
            using (var myConn = new SqlConnection(SqlConnStr))
            {
                using (var myCommand = new SqlCommand(querySql, myConn))
                {
                    myConn.Open();
                    using (var myReader = myCommand.ExecuteReader())
                    {
                        var myda = new SqlDataAdapter(querySql, myConn);
                        myda.Fill(myds);
                        myReader.Close();
                    }
                    myConn.Close();
                }
            }

            if (isJson)
                JsonReportData.GenDetailData(response, myds, toCompress);
            else
                XmlReportData.GenDetailData(response, myds, toCompress);
        }

        public static DataSet DoGenDetailData(string querySql)
        {
            var myds = new DataSet();
            using (var myConn = new SqlConnection(SqlConnStr))
            {
                using (var myCommand = new SqlCommand(querySql, myConn))
                {
                    myConn.Open();
                    using (var myReader = myCommand.ExecuteReader())
                    {
                        var myda = new SqlDataAdapter(querySql, myConn);
                        myda.Fill(myds);
                        myReader.Close();
                    }
                    myConn.Close();
                }
            }

            return myds;
        }

        //根据查询 SQL,产生提供给报表生成需要的 XML 或 JSON 数据，采用 Sql 数据引擎, 这里只产生报表参数数据
        //当报表没有明细时，调用本方法生成数据，查询 SQL 应该只能查询出一条记录
        private static void DoGenParameterData(System.Web.UI.Page dataPage, string parameterQuerySql, bool isJson)
        {
            DoGenParameterData(dataPage.Response, parameterQuerySql, isJson);
        }

        private static void DoGenParameterData(HttpResponse dataPage, string parameterQuerySql, bool isJson)
        {
            using (var myConn = new SqlConnection(SqlConnStr))
            {
                using (var myCommand = new SqlCommand(parameterQuerySql, myConn))
                {
                    myConn.Open();
                    using (var myReader = myCommand.ExecuteReader())
                    {
                        if (isJson)
                            JsonReportData.GenParameterData(dataPage, myReader);
                        else
                            XmlReportData.GenParameterData(dataPage, myReader);
                        myReader.Close();
                    }
                    myConn.Close();
                }
            }
        }

        //根据查询SQL,产生提供给报表生成需要的 或 JSON 数据，采用 Sql 数据引擎, 根据RecordsetQuerySQL获取报表明细数据，根据ParameterQuerySQL获取报表参数数据
        private static void DoGenEntireData(System.Web.UI.Page dataPage, string recordsetQuerySql, string parameterQuerySql, bool toCompress, bool isJson)
        {
            DoGenEntireData(dataPage.Response, recordsetQuerySql, parameterQuerySql, toCompress, isJson);
        }

        private static void DoGenEntireData(HttpResponse dataPage, string recordsetQuerySql, string parameterQuerySql, bool toCompress, bool isJson)
        {
            var myds = new DataSet();
            using (var myConn = new SqlConnection(SqlConnStr))
            {
                myConn.Open();
                using (var myda = new SqlDataAdapter(recordsetQuerySql, myConn))
                {
                    myda.Fill(myds);
                }
                using (var mycmd = new SqlCommand(parameterQuerySql, myConn))
                {
                    var mydr = mycmd.ExecuteReader(CommandBehavior.CloseConnection);

                    if (isJson)
                    {
                        string parameterPart = JsonReportData.GenParameterText(mydr);
                        JsonReportData.GenEntireData(dataPage, myds, ref parameterPart, toCompress);
                    }
                    else
                    {
                        string parameterPart = XmlReportData.GenParameterText(mydr);
                        XmlReportData.GenEntireData(dataPage, myds, ref parameterPart, toCompress);
                    }
                }
                myConn.Close();
            }
        }
    }
}